//package com.zhdl.modules.eastdosing;
//
//import com.project.common.util.DelayUtil;
//import com.zhdl.hardware.io.smartLink.repository.impl.IOCmdHandleDaoImpl;
//import com.zhdl.hardware.io.smartLink.service.IOCmdSendService;
//import com.zhdl.hardware.motor.buke.repository.impl.BukePortCmdHandle;
//import com.zhdl.hardware.ranging.myantenna.service.MTRangingCmdSendService;
//import com.zhdl.hardware.robot.borunte.repository.impl.BorunteCmdHandleDaoImpl;
//import com.zhdl.hardware.robot.borunte.service.BorunteCmdSendService;
//import com.zhdl.modules.autopick.entity.CameraCoordinate;
//import com.zhdl.modules.autopick.repository.CameraRepository;
//import com.zhdl.modules.autopick.service.CameraService;
//import com.zhdl.modules.eastdosing.service.CameraEastService;
//import com.zhdl.modules.tools.CommonCallback;
//import com.zhdl.network.service.impl.RobotArmServiceImpl;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.stereotype.Component;
//
//import javax.annotation.Resource;
//import java.io.File;
//import java.io.IOException;
//import java.nio.file.Files;
//import java.nio.file.StandardCopyOption;
//import java.util.ArrayList;
//import java.util.Arrays;
//import java.util.List;
//import java.util.Optional;
//
//@Slf4j
//@Component
//public class EastDosingProcess2 {
//
//    private String ioNum = "30";
//
//    /**
//     * 主进度 流程进度 - 机器人
//     * 分支进度 流程进度 - 电机
//     */
//    public int processRobot = -1, processMotor = -1, warnId = -1;
//    /**
//     * 当前流程是否在运行 - 默认未运行
//     * 当前流程是否在测试 - 默认未测试
//     * true 运行 false 未运行
//     */
//    public boolean isRunning = false,isTest = false;
//    /**
//     * 是否初始化完成 --- 机器人
//     * 是否初始化完成 --- 电机
//     */
//    public boolean robotInit = false, motorInitN = false, motorInitB = false;
//    /**
//     * pcb板的查询存储
//     */
//    public List<Byte> ioStatusDto02 = new ArrayList<>();
//
//    @Resource
//    private BorunteCmdSendService borunteCmdSendService;
//    @Resource
//    private BorunteCmdHandleDaoImpl borunteCmdHandleDao;
//    @Resource
//    private BukePortCmdHandle bukePortCmdHandle;
//    @Resource
//    private IOCmdSendService ioCmdSendService;
//    @Resource
//    private IOCmdHandleDaoImpl ioCmdHandleDao;
//    @Resource
//    private CameraEastService cameraService;
//
//    @Resource
//    private CameraRepository cameraRepository;
//
//    /**
//     * 东区加药 - 上电初始化
//     */
//    public void init(){
//        /*
//            1. 初始化IO模块网口
//            2. 初始化步科电机串口
//         */
//        ioCmdHandleDao.init("192.168.1.108:502");
//        borunteCmdHandleDao.init("192.168.4.4:502");
//        bukePortCmdHandle.addPort("2");
//        bukePortCmdHandle.addPort("1");
//        /*
//            1. 开启读取IO模块信号
//         */
//        ioCmdSendService.readAllCoil02(ioNum, bytes -> {
//            ioStatusDto02 = bytes;
//            log.info("IO信号为:" + bytes);
//            /*
//                判断是否是在调试状态 如果在就退出流程
//            */
//            if (!isTest) {
//                if (bytes.get(8) == 0){
//                    log.info("料盒-北料斗报警");
//                    eastDosingProcess(8);
//                } else if (bytes.get(14) == 0){
//                    log.info("料盒-南料斗报警");
//                    eastDosingProcess(14);
//                }
//            }
//        });
//        /*
//            1. 写入空压机开启
//            2. 写入压板上合
//            3. 写入夹爪闭合
//         */
//        ioCmdSendService.ioWriteCoil05(0, true, s ->
//                log.info("机器人-空压机开启完成"));
//        ioCmdSendService.ioWriteCoil05(3, false, s ->
//                log.info("机器人-压板上合完成"));
//        DelayUtil.delayedExecution(200, () ->
//                ioCmdSendService.ioWriteCoil05(1, false, s ->
//                        log.info("机器人-夹爪闭合完成")));
//
//        /*
//            判断电机是否进行初始化，如果没有，则电机进行初始化
//         */
//        motorInitB = true;
//        motorInitN = true;
//
//        /*
//            判断机器人是否进行初始化，如果没有，则机器人进行初始化
//         */
//        if (!robotInit) {
//            processRobot = 2;
//            nextIntRobot();
//        }
//    }
//
//    /**
//     * 东区加药 - 流程开始入口
//     */
//    public void eastDosingProcess(int id){
//
//        log.info("==========================当前不为测试模式，自动流程开始了==========================");
//
//        /* 判断初始化是否完成 */
//        if (!motorInitB || !motorInitN || !robotInit) {
//            log.info("当前初始化状态，motor N&B+" + motorInitN + motorInitB + ",robot+" + robotInit);
//            return;
//        }
//
//        /* 判断当前是否有流程正在进行 */
//        if (isRunning) {
//            return;
//        }
//        isRunning = true;
//
//        /* 保存报警id */
//        warnId = id;
//
//        log.info("当前料盒id为:" + id +
//                ",即将判断是否有料--------------------->");
//
//        Optional<CameraCoordinate> byId = cameraRepository.findById(1);
//        CameraCoordinate coordinate = byId.get();
//        String cameraParam = coordinate.getCameraParam();
//        if (cameraParam==null || "".equals(cameraParam)) {
//            processRobot = 0;
//            nextIntRobot();
//        } else {
//            if (coordinate.getBagNum()==5) {
//                processRobot = 0;
//                nextIntRobot();
//            } else {
//                String[] split = cameraParam.split("\\|");
//                int num = coordinate.getBagNum()+1;
//                String s = split[num-1];
//                String[] split1 = s.split(",");
//                for (int i = 0; i < 3; i++) {
//                    pickLocation[i] = (int) (Float.parseFloat(split1[i])*1000);
//                }
//                RobotArmServiceImpl.orientation = (int) Float.parseFloat(split1[3]);
//                /* 机器人 - 流程开始运动 */
//                coordinate.setBagNum(num);
//                cameraRepository.save(coordinate);
//                processRobot = 4;
//                nextIntRobot();
//            }
//        }
////
////        /* IO查询 - 机械手有无负重 */
////        //IO查询 - 02查询 第 0 位为机械手负重 0 为无料
////        if (ioStatusDto02.get(0) == 0) {
////            log.info("流程正常开始-电机漏斗无料-" +
////                    "机械抓手无料-开始控制相机拍照");
////            /* 机器人 - 流程开始运动 */
////            processRobot = 3;
////            nextIntRobot();
////        } else {    /* IO查询 - 机械手有无负重 */
////            //IO查询 - 02查询 第 0 位为机械手负重 1 为有料
////            processRobot = 5;
////            nextIntRobot();
////        }
//    }
//
//    private String currentFileName;
//
//    int[] pickLocation = new int[3];
//
//    /**
//     * 東區加藥-伯朗特機器人流程
//     */
//    public void nextIntRobot() {
//        /* 机器人进度 */
//        processRobot++;
//        /* 判断机器人当前进度 */
//        switch (processRobot) {
//            /* case 1,2 为相机拍照流程 */
//            case 1 -> {
//                /* 控制相机拍照 */
//                cameraService.takePhoto();
//                /* 遍历文件夹是否为最新 */
//                String path = "E:\\BaiduSyncdisk\\project\\photo";
//                DelayUtil.delayedExecution(5000, () -> {
//                    File file = new File(path);
//                    File[] files = file.listFiles();
//                    if (files != null && files.length > 0) {
//                        currentFileName = files[0].getName();
//                        nextIntRobot();
//                        log.info("相机-视觉拍照");
//
//                        /* 将结果删掉为空 */
//                        String pathResult = "E:\\BaiduSyncdisk\\project\\result\\subworldauto";
//                        File fileResult = new File(pathResult);
//                        boolean delete = fileResult.delete();
//                        log.info("删除文件夹成功结果"+ delete);
//
//                        /* 将袋子参数置为空 */
//                        Optional<CameraCoordinate> byId1 = cameraRepository.findById(1);
//                        CameraCoordinate coordinate1 = byId1.get();
//                        coordinate1.setBagNum(0);
//                        coordinate1.setCameraParam("");
//                        cameraRepository.save(coordinate1);
//                    } else {
//                        /* 如果拍照失败，则重试 */
//                        isRunning = false;
//                        log.info("移动失败");
//                    }
//                });
//            }
//            case 2 -> {
//                cameraService.getComputeResult();
//
//                File file1 = new File("E:\\BaiduSyncdisk\\project\\photo\\" + currentFileName);
//                File file2 = new File("E:\\BaiduSyncdisk\\project\\backupPhoto\\" + currentFileName);
//                try {
//                    Files.move(file1.toPath(),file2.toPath(), StandardCopyOption.REPLACE_EXISTING);
//                } catch (IOException e) {
//                    throw new RuntimeException(e);
//                }
//
//                Optional<CameraCoordinate> byId = cameraRepository.findById(1);
//                CameraCoordinate coordinate = byId.get();
//                String cameraParam = coordinate.getCameraParam();
//                String[] split = cameraParam.split("\\|");
//                int num = coordinate.getBagNum();
//                String s = split[num];
//                String[] split1 = s.split(",");
//                for (int i = 0; i < 3; i++) {
//                    pickLocation[i] = (int) (Float.parseFloat(split1[i])*1000);
//                }
//                RobotArmServiceImpl.orientation = (int) Float.parseFloat(split1[3]);
//                coordinate.setBagNum(num+1);
//                cameraRepository.save(coordinate);
//                /* 机器人 - 流程开始运动 */
//                processRobot = 4;
//                nextIntRobot();
//
//            }
//            /* case 3 为机器人初始化流程 */
//            /* 机器人初始化 - 读取机器人世界坐标,设置原点Z轴高度 */
//            case 3 -> {
//                /*
//                    1. 设置机器人原点Z轴高度
//                    2. 写入M12回原点信号
//                    3. 读取M22回原点完成信号
//                 */
//
//                borunteCmdSendService.borunteSetOriginZ(s -> {
//                    borunteCmdSendService.borunteWriteStatusM(162, true);
//                    log.info("机器人-机械臂 初始化 M12");
//                    borunteCmdSendService.borunteReadStatusM(170, 3000, s1 -> {
//                        borunteCmdSendService.borunteWriteStatusM(170,false);
//                        robotInit = true;
//                        log.info("机器人-机械臂 初始化完成 M22");
//                    });
//                });
//
//            }
//            /* case 4 机器人流程正式开始 */
//            /* 1. 机器人-机械臂 移动到料袋准备抓料 */
//            case 4 -> {
//                /*
//                    1.1 写入抓料点位置 , 写入抓料点正上方位置
//                    1.2 通知信号 - M10 - 开始抓料
//                    1.3 读取信号 - M121 - 等待通知夹料气缸夹紧
//                 */
//                borunteCmdSendService.borunteSetPickLocation(
//                        pickLocation, s -> {
//                            borunteCmdSendService.borunteWriteStatusM(160, true);
//                            log.info("机器人-机械臂 写入M10 开始抓料信号");
//                        /*
//                            1.4 电机流程开始 - 打开料斗盖子准备好
//                            1.5 打开机械爪准备抓料
//                         */
//                            ioCmdSendService.ioWriteCoil05(1, true, s14 ->
//                                    log.info("机械爪打开等待抓料"));
//
//                            processMotor = 0;
//                            if (warnId == 8){
//                                nextIntMotorB();
//                            }
//                            if (warnId == 14){
//                                nextIntMotorN();
//                            }
//
//                            borunteCmdSendService.borunteReadStatusM(201, 3000, s1 -> {
//                                borunteCmdSendService.borunteWriteStatusM(201,false);
//                                nextIntRobot();
//                                log.info("机器人-机械臂 读取M121 读取气缸夹紧");
//
//                            });
//                        }
//                );
//            }
////            case 5 -> {
////
////                borunteCmdSendService.borunteReadStatusM(165, 3000, new CommonCallback<String>() {
////                    @Override
////                    public void statusCallback(String s) {
////                        borunteCmdSendService.borunteWriteStatusM(165,false);
////                        nextIntRobot();
////                        log.info("机器人-机械臂 读取M15 读取气缸夹紧");
////                    }
////                });
////            }
//            /* 2. 机器人-机械臂 等待信号抓具夹紧 */
//            case 5 -> {
//                /*
//                    2.1 IO控制 - 控制气缸夹紧
//                    2.2 回应信号 - M111 - 写入气缸夹紧完成
//                    2.3 读取信号 - M20 - 等待抓料完成信号
//                 */
//                ioCmdSendService.ioWriteCoil05(1, false, s -> {
//                    log.info("IO控制-机器人气缸夹紧完成");
//                    borunteCmdSendService.borunteWriteStatusM(193, true);
//                    log.info("机器人-机械臂 写入M111信号 气缸夹紧完成");
//                });
//                borunteCmdSendService.borunteReadStatusM(168, 3000, s -> {
//                    borunteCmdSendService.borunteWriteStatusM(168,false);
//                    nextIntRobot();
//                    log.info("机器人-机械臂 读取M20 读取抓料完成信号");
//                });
//            }
//            /* 3. 机器人-机械臂 等待抓料完成-通知机器人去放料 */
//            case 6 -> {
//                /*
//                    3.1 通知信号 - M11 - 通知放料开始
//                    3.2 读取信号 - M124 - 读取抖料信号
//                 */
//                if (warnId==8) {
//                    borunteCmdSendService.borunteWriteStatusM(161, true);
//                    log.info("机器人-机械臂 写入M11信号 通知放料开始");
//                }
//                if (warnId==14) {
//                    borunteCmdSendService.borunteWriteStatusM(163, true);
//                    log.info("机器人-机械臂 写入M13信号 通知放料开始");
//                }
//
//                borunteCmdSendService.borunteReadStatusM(204, 3000, s -> {
//                    borunteCmdSendService.borunteWriteStatusM(204,false);
//                    nextIntRobot();
//                    log.info("机器人-机械臂 读取M124 读取通知抖料信号");
//                });
//            }
//            /* 4. 机器人-机械臂 等待抖料信号-抓具抖动 */
//            case 7 -> {
//                /*
//                    4.1 IO控制 - 控制夹具往返抖动4次
//                    4.2 回应信号 - M114 - 抖料完成
//                    4.3 读取信号 - M21 - 放料完成信号
//                 */
//                ioCmdSendService.ioWriteCoil05(5, true, s ->
//                        ioCmdSendService.ioWriteCoil05(5, false, s1 ->
//                                ioCmdSendService.ioWriteCoil05(5, true, s11 ->
//                                        ioCmdSendService.ioWriteCoil05(5, false, s1112 ->
//                                                ioCmdSendService.ioWriteCoil05(5, true, s111 ->
//                                                        ioCmdSendService.ioWriteCoil05(5, false, s1111 ->
//                                                                ioCmdSendService.ioWriteCoil05(5, true, s2 ->
//                                                                        ioCmdSendService.ioWriteCoil05(5, false, s21 -> {
//                                                                            borunteCmdSendService.borunteWriteStatusM(196, true);
//                                                                            log.info("机器人-机械臂 写入M114信号 回应抖料完成");
//                                                                            borunteCmdSendService.borunteReadStatusM(169, 3000, s3 -> {
//                                                                                ioCmdSendService.ioWriteCoil05(169, false, new CommonCallback<String>() {
//                                                                                    @Override
//                                                                                    public void statusCallback(String s) {
//                                                                                        nextIntRobot();
//                                                                                        log.info("机器人-机械臂 读取M21 读取放料完成信号");
//                                                                                    }
//                                                                                });
//                                                                            });
////                                                                            if (warnId==8) {
////
////                                                                            }
////                                                                            if (warnId==14) {
////                                                                                borunteCmdSendService.borunteReadStatusM(171, 3000, s3 -> {
////                                                                                    borunteCmdSendService.borunteWriteStatusM(171,false);
////                                                                                    nextIntRobot();
////                                                                                    log.info("机器人-机械臂 读取M23 读取放料完成信号");
////                                                                                });
////                                                                            }
//                                                                        },1000),1000),2000),1000),1000),1000),1000),1000);
//            }
//            /* case 8 电机流程正式开始 */
//            /* 5. 机器人-机械臂 等待夹具松开信号 */
//            case 8 -> {
//                /*
//                    电机流程开始-盖子合上
//                 */
//                processMotor = 2;
//
//                if (warnId == 8){
//                    nextIntMotorB();
//                }
//
//                if (warnId == 14){
//                    nextIntMotorN();
//                }
//                /*
//                    5.1 读取信号 - M120 - 通知夹具松开
//                 */
//                borunteCmdSendService.borunteReadStatusM(200, 3000, s -> {
//                    borunteCmdSendService.borunteWriteStatusM(200,false);
//                    nextIntRobot();
//                    log.info("机器人-机械臂 读取M120 读取通知夹具松开");
//                });
//            }
//            /* 6. 机器人-机械臂 控制夹具松开 */
//            case 9 -> {
//                /*
//                    6.1 IO控制 - 控制夹具松开
//                    6.2 回应信号 - M110 - 夹具松开完成
//                    6.3 等待信号 - M122 - 气缸下推信号
//                 */
//                ioCmdSendService.ioWriteCoil05(1, true, s -> {
//                    borunteCmdSendService.borunteWriteStatusM(192, true);
//                    log.info("机器人-机械臂 写入M110信号 回应夹具松开完成");
//                    borunteCmdSendService.borunteReadStatusM(202, 3000, s12 -> {
//                        borunteCmdSendService.borunteWriteStatusM(202,false);
//                        nextIntRobot();
//                        log.info("机器人-机械臂 读取M122 读取通知气缸下推动作");
//                    });
//                });
//            }
//            /* 7. 机器人-机械臂 控制气缸下推 */
//            case 10 -> {
//                /*
//                    7.1 IO控制 - 控制气缸下推
//                    7.2 回应信号 - M112 - 气缸下推完成
//                    7.3 等待信号 - M123 - 等待气缸上回动作
//                 */
//                ioCmdSendService.ioWriteCoil05(3, true, s -> {
//                    borunteCmdSendService.borunteWriteStatusM(194, true);
//                    log.info("机器人-机械臂 写入M112 回应气缸下推动作完成");
//                    borunteCmdSendService.borunteReadStatusM(203, 3000, s13 -> {
//                        borunteCmdSendService.borunteWriteStatusM(203,false);
//                        nextIntRobot();
//                        log.info("机器人-机械臂 读取M123 读取通知气缸下推动作");
//                    });
//                });
//            }
//            /* 8. 机器人-机械臂 等待IO压板到位 */
//            case 11 -> {
//                ioCmdSendService.ioReadCoil02(ioNum,1, 0, 3000, s -> {
//                    nextIntRobot();
//                    log.info("IO控制-压板到位");
//                });
//            }
//            /* 9. 机器人-机械臂 控制气缸上回 */
//            case 12 -> {
//                /*
//                    9.1 IO控制 - 控制气缸上回
//                    9.2 回应信号 - M113 - 气缸上回完成
//                 */
//                /* 9.3 IO控制 - 流程结束后，默认关闭机械爪 */
//
//                ioCmdSendService.ioWriteCoil05(3, false, s ->
//                        ioCmdSendService.ioWriteCoil05(1, false, s1 ->
//                                ioCmdSendService.ioWriteCoil05(1, true, s11 ->
//                                        ioCmdSendService.ioWriteCoil05(3, true, s1112 ->
//                                                ioCmdSendService.ioWriteCoil05(3, false, s111 ->
//                                                        ioCmdSendService.ioWriteCoil05(1, false, s1111 ->
//                                                                ioCmdSendService.ioWriteCoil05(1, true, s2 ->
//                                                                        ioCmdSendService.ioWriteCoil05(3, true, s21 -> {
//                                                                            ioCmdSendService.ioWriteCoil05(3, false, s32 ->
//                                                                                    ioCmdSendService.ioWriteCoil05(1, false, s321 -> {
//                                                                                        borunteCmdSendService.borunteWriteStatusM(195, true);
//                                                                                        log.info("机器人-机械臂 写入M113信号 回应气缸上回到位");
//                                                                                        nextIntRobot();
//                                                                                    }),1000);
//                                                                        },1000),1000),1000),1000),1000),1000),1000),1000);
//            }
//            case 13 ->{
//                DelayUtil.delayedExecution(30000, () -> {
//                    processFinish();
//                    log.info("机器人-流程结束");
//                });
//            }
//            default -> log.info("机器人-流程出现异常");
//        }
//    }
//
//    /**
//     * 東區加藥-步科电机流程-南边电机
//     */
//    public void nextIntMotorN(){
//        processMotor++;
//        switch (processMotor){
//            case 1 -> {
//                bukePortCmdHandle.bukeMotorRun("2","01",290000,50);
//                log.info("南边电机打开料盒");
//                nextIntMotorN();
//            }
//            case 2 -> {
//                //bukePortCmdHandle.bukeGetStatus("2","01");
//                bukePortCmdHandle.bukeMotorStop("2","01");
//                log.info("停止-打开");
//            }
//            case 3 -> {
//                bukePortCmdHandle.bukeMotorRun("2","01",0,50);
//                log.info("南边电机关闭料盒");
//                nextIntMotorN();
//            }
//            case 4 -> {
//                //bukePortCmdHandle.bukeGetStatus("2","01");
//                bukePortCmdHandle.bukeMotorStop("2","01");
//                log.info("停止-回去");
//            }
//            default -> log.info("东区加药-电机流程异常");
//        }
//    }
//
//    /**
//     * 东区加药-步科电机流程-北边电机
//     */
//    public void nextIntMotorB(){
//        processMotor++;
//        switch (processMotor){
//            case 1 -> {
//                bukePortCmdHandle.bukeMotorRun("2","02",290000,50);
//                log.info("北边电机打开料盒");
//                nextIntMotorB();
//            }
//            case 2 -> {
//                //bukePortCmdHandle.bukeGetStatus("2","02");
//                if (ioStatusDto02.get(6)==1) {
//                    bukePortCmdHandle.bukeMotorStop("2","02");
//                }
//                log.info("停止-打开");
//            }
//            case 3 -> {
//                bukePortCmdHandle.bukeMotorRun("2","02",0,50);
//                log.info("北边电机关闭料盒");
//                nextIntMotorB();
//            }
//            case 4 -> {
//                //bukePortCmdHandle.bukeGetStatus("2","02");
//                if (ioStatusDto02.get(6)==1) {
//                    bukePortCmdHandle.bukeMotorStop("2","02");
//                }
//                log.info("停止-回去");
//            }
//            default -> log.info("东区加药-电机流程异常");
//        }
//    }
//
//    /**
//     * 判断流程结束信号
//     */
//    public void processFinish(){
//        if (processRobot >= 13){
////            if (processMotor >= 14){
////                processRobot = -1;
////                processMotor = -1;
////                isRunning = false;
////                warnId = -1;
////            }
//            processRobot = -1;
//            processMotor = -1;
//            isRunning = false;
//            warnId = -1;
//        }
//    }
//}